package mx.ipn.servicios;

import java.sql.Date;

import org.apache.axis2.AxisFault;

import mx.ipn.to.*;
import mx.ipn.negocios.*;
import mx.ipn.negocios.telefonista.*;
import mx.ipn.negocios.facturacion.*;
import mx.ipn.negocios.radioperadora.*;
import mx.ipn.negocios.nomina.*;
import mx.ipn.negocios.reportes.*;
import mx.ipn.Constantes;
import mx.ipn.negocios.empleado.*;

/* Clase para publicar todas las reglas de 
 * negocio en AXIS2 y asi mantenerlas bajo 
 * el mismo war
 */

public class Negocios {

	// El servicio de login
	public UsuarioTO login(UsuarioTO usuarioTO) {
		return LoginBO.validarLogin(usuarioTO);
	}

	/* Conexion de presentacion */
	public TransferObject conectar(){
		return UrlServidorBO.conectar();
	}
	
	/* Conexion con persistencia */
	public void setUrlServidor(String url){
		UrlServidorBO.setUrl(url);
	}
	
	public TransferObject setPuertoServidor(String port){
		TransferObject to;
		UrlServidorBO.setPort(port);
		
		try {
			ConexionConPersistencia.inicializar();
			to = ConexionConPersistencia
					.iniciarFabricaDAOS(Constantes.FABRICA_DAOS_MYSQL);
			
			if(to==null){
				to = new TransferObject();
				to.setTipoError(TransferObject.ERROR);
				to.setError(CodigosDeError.error.get(4));
				return to;
			}
			else{
				to.setTipoError(TransferObject.INFO);
				to.setError(CodigosDeError.error.get(5));
				UrlServidorBO.setConnected(true);
				return to;
			}
		} catch (AxisFault e) {
			to = new TransferObject();
			to.setTipoError(TransferObject.ERROR);
			to.setError(CodigosDeError.error.get(4));
			e.printStackTrace();
			
			return to;
		}
	}
	
	/* Telefonista - Agregar Servicio */
	public ClienteTO[] obtenerClientesPorTelefono(String telefono) {
		return AgregarServicioBO.obtenerClientesPorTelefono(telefono);
	}

	public ClienteDireccionTO obtenerDirecciones(int idCliente) {
		return AgregarServicioBO.obtenerDirecciones(idCliente);
	}

	public TipoServicioTO[] obtenerTiposServicio() {
		return AgregarServicioBO.obtenerTiposServicio();
	}

	public FormaPagoTO[] obtenerFormasPago() {
		return AgregarServicioBO.obtenerFormasPago();
	}

	public TransferObject agregarServicio(BitacoraServicioTO bitacora) {
		return BitacoraServiciosBO.agregarServicio(bitacora);
	}

	public BitacoraServicioTO obtenerBitacoraServiciosPorFechaTelefonista(
			PeticionBitacoraServicioTO to) {
		return mx.ipn.negocios.telefonista.BitacoraServiciosBO
				.obtenerBitacoraPorFechaTelefonista(to);
	}

	public PeticionBitacoraServiciosPorRevisionTO obtenerBitacoraServiciosPorDia(
			java.util.Date dia) {
		return mx.ipn.negocios.telefonista.BitacoraServiciosBO
				.obtenerBitacoraPorDia(dia);
	}
	
	public PeticionBitacoraServiciosPorRevisionTO obtenerBitacoraServiciosPorRevision(short revision) {
		return mx.ipn.negocios.telefonista.BitacoraServiciosBO.obtenerRevision(revision);
	}
	
	public TransferObject actualizarBitacoraServicios(
			PeticionBitacoraServiciosPorRevisionTO to) {
		return mx.ipn.negocios.telefonista.BitacoraServiciosBO
				.actualizarBitacoraServicios(to);
	}
	
	/* Telefonista - Direcciones */

	public EstadoTO[] obtenerEstados() {
		return DireccionBO.obtenerEstados();
	}

	public TransferObject modificarEstado(EstadoTO estadoTO) {
		return DireccionBO.modificarEstado(estadoTO);
	}

	public TransferObject agregarEstado(EstadoTO estadoTO) {
		return DireccionBO.agregarEstado(estadoTO);
	}

	public MunicipioTO obtenerMunicipiosPorEstado(short idEstado) {
		return DireccionBO.obtenerMunicipiosPorEstado(idEstado);
	}

	public TransferObject modificarMunicipio(MunicipioTO municipioTO) {
		return DireccionBO.modificarMunicipio(municipioTO);
	}

	public TransferObject agregarMunicipio(MunicipioTO municipioTO) {
		return DireccionBO.agregarMunicipio(municipioTO);
	}

	public ColoniaTO obtenerColoniasPorMunicipio(int idMunicipio) {
		return DireccionBO.obtenerColoniasPorMunicipio(idMunicipio);
	}

	public TransferObject modificarColonia(ColoniaTO coloniaTO) {
		return DireccionBO.modificarColonia(coloniaTO);
	}

	public TransferObject agregarColonia(ColoniaTO coloniaTO) {
		return DireccionBO.agregarColonia(coloniaTO);
	}

	public TransferObject agregarColoniaCalle(ColoniaCalleTO coloniaCalleTO) {
		return DireccionBO.agregarColoniaCalle(coloniaCalleTO);
	}

	public ColoniaCalleTO obtenerCallesPorColonia(int idColonia) {
		return DireccionBO.obtenerCallesPorColonia(idColonia);
	}

	public TransferObject modificarCalle(CalleTO calleTO) {
		return DireccionBO.modificarCalle(calleTO);
	}

	public CalleTO agregarCalle(CalleTO calleTO) {
		return DireccionBO.agregarCalle(calleTO);
	}

	public DireccionTO obtenerDireccionesPorColoniaCalle(int idColoniaCalle) {
		return DireccionBO.obtenerDireccionesPorColoniaCalle(idColoniaCalle);
	}

	public TransferObject modificarDireccion(DireccionTO direccionTO) {
		return DireccionBO.modificarDireccion(direccionTO);
	}

	public TransferObject agregarDireccion(DireccionTO direccionTO) {
		return DireccionBO.agregarDireccion(direccionTO);
	}

	/* Telefonista - Clientes */
	public TransferObject agregarCliente(ClienteTO clienteTO) {
		return ClienteBO.agregarCliente(clienteTO);
	}

	/** modulo de facturacion* */
	public BitacoraSTO[] verServicios() {
		return Facturas.verServicios();
	}

	public ClienteRfcTO selectClienteRfcActivoByIdCliente(int idCliente) {
		return Facturas.selectClienteRfcActivoByIdCliente(idCliente);
	}

	public static RfcTO findRfcById(int idrfc) {
		return Facturas.findRfcById(idrfc);
	}

	public static RfcTO findRfcByRegistro(String registro) {
		return Facturas.findRfcByRegistro(registro);
	}

	public static RfcTO findRfcByDenominacion(String denominacion) {
		return Facturas.findRfcByDenominacion(denominacion);
	}

	public RfcTO[] selectRfc() {
		return Facturas.selectRfc();
	}

	public FacturaTO[] verFacturas(int mes, int anio) {
		return Facturas.verFacturas(mes, anio);
	}

	public DetallePrefacturaTO[] verDetallePrefactura(String rfc) {
		return Facturas.verDetallePrefactura(rfc);
	}

	public boolean crearDetallePrefactura(DetallePrefacturaTO detpf) {
		return Facturas.crearDetallePrefactura(detpf);
	}

	public boolean crearDetalleFactura(DetalleFacturaTO det) {
		return Facturas.crearDetalleFactura(det);
	}

	public DetalleFacturaTO[] selectDetalleFactura() {
		return Facturas.selectDetalleFactura();
	}

	public FacturaTO[] selectFactura() {
		return Facturas.selectFactura();
	}

	public boolean crearFactura(FacturaTO facto) {
		return Facturas.crearFactura(facto);
	}

	public ClienteTO[] listaDeClientes() {
		return Facturas.listaDeClientes();
	}

	public ClienteTO[] buscarCliente(String nombre) {
		return Facturas.buscarCliente(nombre);
	}

	public ClienteTO[] buscarClienteRfc(String rfc) {
		return Facturas.buscarClienteRfc(rfc);
	}

	public short borraFactura(int idFactura) {
		return Facturas.borraFactura(idFactura);
	}

	public short eliminaDetalleFactura(int idFactura) {
		return Facturas.eliminaDetalleFactura(idFactura);
	}

	public short setConsiderado(int id, boolean considerado) {
		return Facturas.setConsiderado(id, considerado);
	}

	public short updateFactura(FacturaTO factura) {
		return Facturas.updateFactura(factura);
	}

	public short updateDetalleFactura(DetalleFacturaTO detallefactura) {
		return Facturas.updateDetalleFactura(detallefactura);
	}
    /****modulo de nomina*************/
	public PuestoSalarioTO[] selectPuestoS() {
		return PuestoSal.selectPuestoS();
	}

	public PuestoSalarioTO PuestoSId(short idps) {
		return PuestoSal.PuestoSId(idps);
	}

	public boolean addPuestoSalario(PuestoSalarioTO puestosalarioTO) {
		return PuestoSal.addPuestoSalario(puestosalarioTO);
	}

	public short modPuestoSalario(PuestoSalarioTO puestosalarioTO) {
		return  PuestoSal.modPuestoSalario(puestosalarioTO);
	}

	public short delPuestoSalario(short idPuesto) {
		return  PuestoSal.delPuestoSalario(idPuesto);
	}
	public boolean addDescuento(DescuentoTO desc) {
		return PuestoSal.addDescuento(desc);
	}
	public  DescuentoTO[] selectDescuento() {
		return  PuestoSal.selectDescuento();
	}
	public short updateDescuento(DescuentoTO desc) {
		return PuestoSal.updateDescuento(desc);
	}
	public boolean insertPercepcion(PercepcionTO per) {
		return PuestoSal.insertPercepcion(per);
	}
	public PercepcionTO[] selectPercepcion() {
		return PuestoSal.selectPercepcion();
	}
	public short updatePercepcion(PercepcionTO per) {
		return  PuestoSal.updatePercepcion(per);
	}
	public boolean insertComprobantePercepcionDescuento(ComprobantePercepcionDescuentoTO comp) {
		return PuestoSal.insertComprobantePercepcionDescuento(comp);
	}
	public ComprobantePercepcionDescuentoTO[] selectComprobantePercepcionDescuento() {
		return PuestoSal.seleccionarCompPercepcionDescuento();
	}
	public short updateCompPD(ComprobantePercepcionDescuentoTO comp) {
		return  PuestoSal.updateCompPD(comp);
	}
	public boolean insertDescuentoPuesto(DescuentoPuestoTO dp) {
		return PuestoSal.insertDescuentoPuesto(dp);
	}
	public boolean registraDHistorial(DescuentoHistorialTO dh) {
		return PuestoSal.registraDHistorial(dh);
	}
	public boolean insertarPercepcionP(PercepcionPuestoTO dp) {
		return PuestoSal.insertarPercepcionP(dp);
	}
	public  boolean registraPerHist(PercepcionHistorialTO dh) {
		return PuestoSal.registraPerHist(dh);
	}
	public  boolean insertarPerEmp(PercepcionEmpleadoTO dp) {
		return PuestoSal.insertarPerEmp(dp);
	}
	public  boolean registraDEmpleado(DescuentoEmpleadoTO dp) {
		return PuestoSal.registraDEmpleado(dp);
	}
	public boolean addRango(RangoTO rango) {
		return PuestoSal.addRango(rango);
	}
	public  boolean insertarDEmpleado(DescuentoEmpleadoTO dp) {
		return PuestoSal.insertarDEmpleado(dp);
	}
	public RangoTO[] selectRango() {
		return PuestoSal.selectRango();
	}
	public boolean insertTipoPercepcionDescuento(TipoPercepcionDescuentoTO tipopd){
		return PuestoSal.insertTipoPercepcionDescuento(tipopd);
	}
	public TipoPercepcionDescuentoTO [] selectTipoPD()
	{
		return PuestoSal.selectTipoPD();
	}
	public DescuentoPuestoTO [] selectDescuentoPuesto()
	{
		return PuestoSal.selectDescuentoPuesto();
	}
	public PercepcionPuestoTO [] selectperpuesto()
	{
		return PuestoSal.selectperpuesto();
	}
	/** *******modulo de operadora*********** */
	public boolean registrarUnidad(UnidadTO unidad) {
		return OperadoraBO.registrarUnidad(unidad);
	}

	public short modificarUnidad(UnidadTO unidad) {
		return OperadoraBO.modificarUnidad(unidad);
	}

	public short eliminarUnidad(int id) {
		return OperadoraBO.eliminarUnidad(id);
	}

	public UnidadTO[] getDatosUnidad(String placas) {
		return OperadoraBO.getDatosUnidad(placas);
	}

	public UnidadTO[] obtenerUnidades() {
		return OperadoraBO.obtenerUnidades();
	}
	
	/** **servicio**** */
	public boolean asignarServicio(BitacoraServicioTO bitacorato) {
		return OperadoraBO.asignarServicio(bitacorato);
	}

	public BitacoraServicioTO[] buscarServicios(String fecha, String cliente) {
		return OperadoraBO.buscarServicios(fecha, cliente);
	}

	public short cancelarServicio(BitacoraServicioTO bitacorato) {
		return OperadoraBO.cancelarServicio(bitacorato);
	}

	/** **chofer**** */
	public boolean agregarChofer(ChoferTO chofer) {
		return OperadoraBO.agregarChofer(chofer);
	}

	public short modificarChofer(ChoferTO chofer) {
		return OperadoraBO.modificarChofer(chofer);
	}

	public short eliminarChofer(int id) {
		return OperadoraBO.eliminarChofer(id);
	}

	public ChoferTO[] getDatosChofer(String nombre, String apellidoPaterno) {
		return OperadoraBO.getDatosChofer(nombre, apellidoPaterno);
	}
	
	public ChoferTO[] obtenerChoferes() {
		return OperadoraBO.obtenerChoferes();
	}

	/** ***base***** */
	public BaseTO[] seleccionarBases(){
		return OperadoraBO.seleccionarBases();
	}
	
	public boolean agregarBase(BaseTO base) {
		return OperadoraBO.agregarBase(base);
	}

	public short modificarBase(BaseTO base) {
		return OperadoraBO.modificarBase(base);
	}

	public short eliminarBase(int id) {
		return OperadoraBO.eliminarBase(id);
	}

	public BaseTO getDatosBase(short id) {
		return OperadoraBO.getDatosBase(id);
	}

	/** ****economico** */
	public boolean agregarEconomico(EconomicoTO economico) {
		return OperadoraBO.agregarEconomico(economico);
	}

	public short modificarEconomico(EconomicoTO economico) {
		return OperadoraBO.modificarEconomico(economico);
	}

	public short eliminarEconomico(int id) {
		return OperadoraBO.eliminarEconomico(id);
	}

	public EconomicoTO[] getDatosEconomico() {
		return OperadoraBO.getDatosEconomico();
	}
	
	public EconomicoTO[] obtenerEconomicos() {
		return OperadoraBO.obtenerEconomicos();
	}

	/** ***castigo*** */
	public boolean agregarCastigo(BitacoraCastigoChoferTO castigo) {
		return OperadoraBO.agregarCastigo(castigo);
	}

	public short modificarCastigo(BitacoraCastigoChoferTO castigo) {
		return OperadoraBO.modificarCastigo(castigo);
	}

	public BitacoraCastigoChoferTO getDatosCastigo(Date inicio, Date fin) {
		return OperadoraBO.getDatosCastigo(inicio, fin);
	}

	/** *choferunidad** */
	public int asignarChoferUnidad(BitacoraChoferUnidadTO choferunidad) {
		return OperadoraBO.asignarChoferUnidad(choferunidad);
	}

	public short modificarChoferUnidad(BitacoraChoferUnidadTO choferunidad) {
		return OperadoraBO.modificarChoferUnidad(choferunidad);
	}

	public BitacoraChoferUnidadTO[] getDatosChoferUnidad(Date inicio, Date fin) {
		return OperadoraBO.getDatosChoferUnidad(inicio, fin);
	}

	/** *tipoempleado** */
	public TipoEmpleadoTO[] obtenerTiposdeEmpleado() {
		return PuestoBO.obtenerTiposdeEmpleado();
	}

	/** *puesto** */
	public PuestoTO[] obtenerPuestosActivos() {
		return PuestoBO.obtenerPuestosActivos();
	}

	public PuestoTO obtenerPuestoActivoporTipoEmpleado(short idTipoEmpleado) {
		return PuestoBO.obtenerPuestoActivoporTipoEmpleado(idTipoEmpleado);
	}

	public PuestoTO encontrarPuestoporIdPuesto(short idPuesto) {
		return PuestoBO.encontrarPuestoporIdPuesto(idPuesto);
	}

	public PuestoTO[] buscarFiltarPuestos(Puesto2TO puestoTO) {
		return PuestoBO.buscarFiltrarPuestos(puestoTO);
	}

	public PuestoTO agregarPuesto(PuestoTO puestoTO) {
		return PuestoBO.agregarPuesto(puestoTO);
	}

	public PuestoTO modificarPuesto(Puesto2TO puestoTO) {
		return PuestoBO.modificarPuesto(puestoTO);
	}

	public PuestoTO bajaPuesto(short idPuesto) {
		return PuestoBO.bajaPuesto(idPuesto);
	}

	/** *turno** */
	public TurnoTO agregarTurno(TurnoTO turnoTO) {
		return TurnoBO.agregarTurno(turnoTO);
	}

	public TurnoTO[] buscarTurnos() {
		return TurnoBO.buscarTurnos();
	}

	public TurnoTO[] encontrarTurnoPorNombre(String nombre) {
		return TurnoBO.encontrarTurnoPorNombre(nombre);
	}

	public TurnoTO[] encontrarTurnoPorRangoInicio(TurnoTO[] rangoTO) {
		return TurnoBO.encontrarTurnoPorRangoInicio(rangoTO);
	}

	public TurnoTO[] encontrarTurnoPorRangoDia(TurnoTO[] rangoTO) {
		return TurnoBO.encontrarTurnoPorRangoDia(rangoTO);
	}

	public TurnoTO[] encontrarTurnoPorRangoDuracion(TurnoTO[] rangoTO) {
		return TurnoBO.encontrarTurnoPorRangoDuracion(rangoTO);
	}

	public TurnoTO bajaTurno(int idTurno) {
		return TurnoBO.bajaTurno(idTurno);
	}

	public TurnoTO modificarTurno(TurnoTO[] arrTurnoTO) {
		return TurnoBO.modificarTurno(arrTurnoTO);
	}

	/** *Empleado** */
	public EmpleadoTO[] buscarEmpleadosActivos() {
		return EmpleadoBO.buscarEmpleadosActivos();
	}

	public ColoniaTO[] buscarColoniasPorMunicipio(int idMunicipio) {
		return EmpleadoBO.buscarColoniasPorMunicipio(idMunicipio);
	}

	public ColoniaCalleTO buscarCallesPorColonia(int idColonia) {
		return EmpleadoBO.buscarCallesPorColonia(idColonia);
	}

	public EmpleadoTO[] jefeDistintoActivo() {
		return EmpleadoBO.jefeDistintoActivo();
	}

	public EmpleadoTO[] encontrarEmpleadoActivoPorCURP(String curp) {
		return EmpleadoBO.encontrarEmpleadoActivoPorCURP(curp);
	}

	public EmpleadoTO[] encontrarEmpleadosActivosPorPaterno(String paterno) {
		return EmpleadoBO.encontrarEmpleadosActivosPorPaterno(paterno);
	}

	public EmpleadoTO[] encontrarEmpleadosActivosPorNombrePaterno(
			PersonaTO personaTO) {
		return EmpleadoBO.encontrarEmpleadosActivosPorNombrePaterno(personaTO);
	}

	public EmpleadoTO[] encontrarEmpleadoActivoPorNss(String nss) {
		return EmpleadoBO.encontrarEmpleadoActivoPorNss(nss);
	}

	public EmpleadoTO[] encontrarEmpleadosActivosPorPuesto(short idPuesto) {
		return EmpleadoBO.encontrarEmpleadosActivosPorPuesto(idPuesto);
	}

	public EmpleadoTO[] encontrarEmpleadosActivosPorJefe(int idJefe) {
		return EmpleadoBO.encontrarEmpleadosActivosPorJefe(idJefe);
	}

	public EmpleadoTO encontrarJefeActivoPorSubordinado(int idSubordinado) {
		return EmpleadoBO.encontrarJefeActivoPorSubordinado(idSubordinado);
	}

	public MunicipioTO[] seleccionarMunicipiosPorEstado(short idEstado) {
		return EmpleadoBO.seleccionarMunicipiosPorEstado(idEstado);
	}

	public String calcularCurp(PersonaTO curpTO) {
		return EmpleadoBO.calcularCurp(curpTO);
	}

	public EmpleadoTO bajaEmpleado(EmpleadoTO bajaTO) {
		return EmpleadoBO.bajaEmpleado(bajaTO);
	}

	public EmpleadoTO agregarEmpleado(EmpleadoTO[] arrEmpleadoTO) {
		return EmpleadoBO.agregarEmpleado(arrEmpleadoTO);
	}

	public EmpleadoTO modificarEmpleado(EmpleadoTO[] arrEmpleadoTO) {
		return EmpleadoBO.modificarEmpleado(arrEmpleadoTO);
	}

	public EmpleadoTO encontrarEmpleadoPorID(int idEmpleado) {
		return EmpleadoBO.encontrarEmpleadoPorID(idEmpleado);
	}

	public UsuarioTO[] encontrarUsuariosPorActivo(boolean activo) {
		return EmpleadoBO.encontrarUsuariosPorActivo(activo);
	}

	public GrupoUsuarioTO[] ObtenerGruposDeUsuario() {
		return EmpleadoBO.ObtenerGruposDeUsuario();
	}

	public UsuarioTO[] encontrarUsuariosPorGrupo(short idGrupoUsuario) {
		return EmpleadoBO.encontrarUsuariosPorGrupo(idGrupoUsuario);
	}

	public UsuarioTO[] encontrarEmpleadoPorNssActivoEInactivo(String nss) {
		return EmpleadoBO.encontrarEmpleadoPorNssActivoEInactivo(nss);
	}

	public UsuarioTO[] encontrarUsuarioPorNombre(String nombreUsuario) {
		return EmpleadoBO.encontrarUsuarioPorNombre(nombreUsuario);
	}

	public UsuarioTO[] obtenerUsuarios() {
		return EmpleadoBO.obtenerUsuarios();
	}

	public UsuarioTO agregarUsuario(UsuarioTO usuarioTO) {
		return EmpleadoBO.agregarUsuarioTO(usuarioTO);
	}

	public UsuarioTO modificarUsuario(UsuarioTO usuarioTO) {
		return EmpleadoBO.modificarUsuarioTO(usuarioTO);
	}

	public UsuarioTO activarDesactivarUsuarioTO(UsuarioTO usuarioTO) {
		return EmpleadoBO.activarDesactivarUsuarioTO(usuarioTO);
	}

	public DiaFestivoTO[] encontrarDiasFestivosActivos() {
		return DiaFestivoBO.encontrarDiasFestivosActivos();
	}

	public DiaFestivoTO encontrarDiaFestivoPorMesDiaActivo(
			DiaFestivoTO diaFestivoTO) {
		return DiaFestivoBO.encontrarDiaFestivoPorMesDiaActivo(diaFestivoTO);
	}

	public DiaFestivoTO agregarDiaFestivo(DiaFestivoTO diaFestivoTO) {
		return DiaFestivoBO.agregarDiaFestivo(diaFestivoTO);
	}
	
	public DiaFestivoTO bajaDiaFestivo(DiaFestivoTO diaFestivoTO) {
		return DiaFestivoBO.bajaDiaFestivo(diaFestivoTO);
	}
	
	public DiaFestivoTO modificarDiaFestivo(DiaFestivoTO diaFestivoTO) {
		return DiaFestivoBO.modificarDiaFestivo(diaFestivoTO);
	}
	public ReporteTO[] generarReporte(ReporteTO reporteTO) {
		return ReportesBO.generarReporte(reporteTO);
	}
	
	public TransferObject validarRangoFecha(HorarioTO horarioTO){
		return HorarioBO.validarRangoFecha(horarioTO);
	}
	public EmpleadoTO[] filtrarEmpleadosConsiderados(FiltroEmpleadoTO filtroTO){
		return HorarioBO.filtrarEmpleadosConsiderados(filtroTO);
	}
	public EmpleadoTO[] agregarEmpleados(FiltroEmpleadoTO filtroTO){
		return HorarioBO.agregarEmpleados(filtroTO);
	}
	public EmpleadoTO[] quitarEmpleados(FiltroEmpleadoTO filtroTO){
		return HorarioBO.quitarEmpleados(filtroTO);
	}
	public BitacoraAsistenciaTO generarRangoBitacoraAsistencia(BitacoraHorarioTO bitacoraHorarioTO){
		return HorarioBO.generarRangoBitacoraAsistencia(bitacoraHorarioTO);
	}
	public BitacoraAsistenciaTO ponerQuitarDescanso(BitacoraAsistenciaTO bitacoraAsistenciaTO){
		return HorarioBO.ponerQuitarDescanso(bitacoraAsistenciaTO);
	}
}